IRIX Base Documentation 2002 November/SGI IRIX Base Documentation 2002 November.iso/usr/share/catman/p_man/cat3/ifl_c/iflLut.z/iflLut

Text File | 2002-10-03 | 14.8 KB | 397 lines

iiiiffffllllLLLLuuuutttt((((3333))))         IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll          iiiiffffllllLLLLuuuutttt((((3333))))



NNNNAAAAMMMMEEEE
     iiiiffffllllLLLLuuuutttt - base class for defining look-up tables


IIIINNNNHHHHEEEERRRRIIIITTTTSSSS FFFFRRRROOOOMMMM
     This is a base class with no inheritance.


HHHHEEEEAAAADDDDEEEERRRR FFFFIIIILLLLEEEE
     #include <il/ilCdefs.h>


CCCCLLLLAAAASSSSSSSS DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
     iflLut is a base class used for accessing and manipulating look-up
     tables. The class definition provides the necessary data structure for
     defining and accessing the look-up table.

     A look-up table is defined by the number of channels, the range of input
     values it expects (the domain), the data type, and the actual look-up
     table data.  There is a table for each channel and the size and data type
     of each table is the same.  The look-up table data is stored in
     iflSequential format. In other words, the table for each channel is
     stored contiguously.  The tables for each channel are packed together
     into a single array.

   UUUUssssiiiinnnngggg iiiiffffllllLLLLuuuutttt
     The iflLut object can either be used to allocate a look-up table whose
     values are filled in by calls to the sssseeeettttVVVVaaaallll() function, or it can be used
     to wrap an object definition around an existing array of lut values.
     Constructors are provided for both of these usages.  When the iflLut
     allocates the tables, it frees them when it is deleted.  If the tables
     are passed to the constructor, then the caller is responsible for the
     management of the table memory.  Once an iflLut is constructed, its table
     can be completely replaced using the sssseeeettttDDDDaaaattttaaaa() function, or it can be
     modified an entry at a time with sssseeeettttVVVVaaaallll().

     The values in the lut can be accesed by getting a pointer to the table
     with ggggeeeettttDDDDaaaattttaaaa(), ggggeeeettttCCCChhhhaaaannnn() or ggggeeeettttOOOOrrrriiiiggggiiiinnnn().  The pointer returned must be
     cast to match the internal type of the table as returned by
     ggggeeeettttDDDDaaaattttaaaaTTTTyyyyppppeeee().  Alternatively, individual entries in the table can be
     accesed using the ggggeeeettttVVVVaaaallll() function.  While less efficient, this function
     is easier to use since ggggeeeettttVVVVaaaallll() automatically converts to double so that
     the data type of the table can be ignored. It also automatically deals
     with and scaling necessary to deal with a domain that is not a one to one
     mapping onto the number of entries in the look up tables.

     The range of values contained in the tables can be interrogated by
     ggggeeeettttRRRRaaaannnnggggeeee(((()))).  The range of values the lut expects as input can be accessed
     with ggggeeeettttDDDDoooommmmaaaaiiiinnnn().






                                                                        PPPPaaaaggggeeee 1111






iiiiffffllllLLLLuuuutttt((((3333))))         IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll          iiiiffffllllLLLLuuuutttt((((3333))))



CCCCLLLLAAAASSSSSSSS MMMMEEEEMMMMBBBBEEEERRRR FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN SSSSUUUUMMMMMMMMAAAARRRRYYYY
     CCCCoooonnnnssssttttrrrruuuuccccttttoooorrrr

          iflLut* iflLutCreate(int numChan, iflDataType dtype, double min,
                               double max, int length)
          iflLut* iflLutNoAlloc(void* table, int numChan, iflDataType dtype,
                                double min, double max, int length)
          iflLut* iflLutCopy(const iflLut* other)

     DDDDeeeessssttttrrrruuuuccccttttoooorrrr

          void iflLutDelete(iflLut* obj)

     BBBBaaaassssiiiicccc aaaattttttttrrrriiiibbbbuuuutttteeeessss

          int iflLutGetNumChans(iflLut *obj)
          iflDataType iflLutGetDataType(iflLut *obj)
          int iflLutGetLength(iflLut *obj)

     EEEEnnnnttttrrrryyyy aaaacccccccceeeessssssss

          double iflLutGetVal(iflLut *obj, double domainIdx, int chan)
          iflStatus iflLutSetVal(iflLut *obj, double val, double domainIdx,
                                 int chan)

     DDDDiiiirrrreeeecccctttt ttttaaaabbbblllleeee aaaacccccccceeeessssssss

          void* iflLutGetOrigin(iflLut *obj, int chan)
          void* iflLutGetChan(iflLut *obj, int chan)
          void* iflLutGetData(iflLut *obj)
          void iflLutSetData(iflLut *obj, void* dataPnt)

     DDDDoooommmmaaaaiiiinnnn aaaannnndddd rrrraaaannnnggggeeee ccccoooonnnnttttrrrroooollll

          void iflLutGetDomain(iflLut *obj, double* min, double* max)
          double iflLutGetDomainMin(iflLut *obj)
          double iflLutGetDomainMax(iflLut *obj)
          double iflLutGetDomainStep(iflLut *obj)
          void iflLutGetRange(iflLut *obj, double* min, double* max)
          iflStatus iflLutSetDomain(iflLut *obj, double min, double max)

     CCCCoooommmmppppaaaarrrriiiissssoooonnnn

          int iflLutIsDiff(iflLut *obj, const iflLut* from)



FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNN DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNNSSSS
     iiiiffffllllLLLLuuuutttt(((())))






                                                                        PPPPaaaaggggeeee 2222






iiiiffffllllLLLLuuuutttt((((3333))))         IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll          iiiiffffllllLLLLuuuutttt((((3333))))



          iflLut* iflLutCopy(const iflLut* other)
          iflLut* iflLutCreate(int numChan, iflDataType dtype, double min,
                               double max, int length)
          iflLut* iflLutNoAlloc(void* table, int numChan, iflDataType dtype,
                                double min, double max, int length)


          Constructors for the iflLut class.  The number of tables or channels
          in the lut is specified by _n_u_m_C_h_a_n and the LUT data type is
          specified by _d_t_y_p_e.  The domain of values the table handles is from
          _m_i_n to _m_a_x.  The length of each table is either _m_a_x-_m_i_n+1 if _l_e_n_g_t_h
          is 0, otherwise it is given by _l_e_n_g_t_h.  A constructor is also
          provided that creates an iflLut whose look-up table data is  pointed
          to by _t_a_b_l_e. Another constructor is provided that copies the tables
          and attributes from the iflLut specified by _o_t_h_e_r into this object

     iiiiffffllllLLLLuuuuttttDDDDeeeelllleeeetttteeee(((())))

          void iflLutDelete(iflLut *obj)


          Deletes an object of class iflLut, thus freeing any associated
          resources.

     ggggeeeettttCCCChhhhaaaannnn(((())))

          void* iflLutGetChan(iflLut *obj, int chan)


          Returns a pointer to the beginning of the table for channel number
          _c_h_a_n.

     ggggeeeettttDDDDaaaattttaaaa(((())))

          void* iflLutGetData(iflLut *obj)


          Returns a pointer to the overall beginning of the tables for all
          channels.  If returns the same value as ggggeeeettttCCCChhhhaaaannnn(0).

     ggggeeeettttDDDDaaaattttaaaaTTTTyyyyppppeeee(((())))

          iflDataType iflLutGetDataType(iflLut *obj)


          Returns the data type of the entries in the look-up table.

     ggggeeeettttDDDDoooommmmaaaaiiiinnnn(((())))

          void iflLutGetDomain(iflLut *obj, double* min, double* max)





                                                                        PPPPaaaaggggeeee 3333






iiiiffffllllLLLLuuuutttt((((3333))))         IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll          iiiiffffllllLLLLuuuutttt((((3333))))



          Returns the domain, in _m_i_n and _m_a_x, that the look-up table handles
          as input.

     ggggeeeettttDDDDoooommmmaaaaiiiinnnnMMMMaaaaxxxx(((())))

          double iflLutGetDomainMax(iflLut *obj)


          Returns the maximum value that the look-up table handles as input.

     ggggeeeettttDDDDoooommmmaaaaiiiinnnnMMMMiiiinnnn(((())))

          double iflLutGetDomainMin(iflLut *obj)


          Returns the minimum value that the look-up table handles as input.

     ggggeeeettttDDDDoooommmmaaaaiiiinnnnSSSStttteeeepppp(((())))

          double iflLutGetDomainStep(iflLut *obj)


          Returns the incremental step in the domain space between adjacent
          entries in the look-up table.

     ggggeeeettttLLLLeeeennnnggggtttthhhh(((())))

          int iflLutGetLength(iflLut *obj)


          Returns the length of a table for an individual channel.

     ggggeeeettttNNNNuuuummmmCCCChhhhaaaannnnssss(((())))

          int iflLutGetNumChans(iflLut *obj)


          Returns the number of channels in the look-up table.

     ggggeeeettttOOOOrrrriiiiggggiiiinnnn(((())))

          void* iflLutGetOrigin(iflLut *obj, int chan)


          Returns a pointer to the entry for value zero of the table for
          channel number _c_h_a_n.

     ggggeeeettttRRRRaaaannnnggggeeee(((())))

          void iflLutGetRange(iflLut *obj, double* min, double* max)





                                                                        PPPPaaaaggggeeee 4444






iiiiffffllllLLLLuuuutttt((((3333))))         IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll          iiiiffffllllLLLLuuuutttt((((3333))))



          Returns the range of values that the look-up table contains in _m_i_n
          and _m_a_x.

     ggggeeeettttVVVVaaaallll(((())))

          double iflLutGetVal(iflLut *obj, double domainIdx, int chan)


          Returns the look-up table entry for channel, _c_h_a_n, and input value,
          _d_o_m_a_i_n_i_d_x.  The domain index is scaled as needed to map onto the
          actual table entries when the table length does not map one to one
          onto the domain.

     int iflLutIsDiff(iflLut *obj, const iflLut* from)



     The method returns TRUE if the the this lut is not identical, in
     attributes and tables contents, to the lut specified by _f_r_o_m; FALSE is
     returned if the luts are the same.

     void iflLutSetData(iflLut *obj, void* dataPnt)



     This function replaces the array of all the tables in the lut with the
     data pointed to be _d_a_t_a.  The array of data is not copied, nor is it
     deallocated when the iflLut is deleted.  The format of the data must
     match the data type, length, and number of channels in the iflLut.  See
     the Class Description section for details on the layout of the look-up
     table data.

     sssseeeettttDDDDoooommmmaaaaiiiinnnn(((())))

          iflStatus iflLutSetDomain(iflLut *obj, double min, double max)


          Sets the range of values that this lut expects to _m_i_n and _m_a_x.  If
          _m_a_x-_m_i_n+1 exceeds the current length of the table, a status of
          iflBADPARAMS is returned; iflOKAY is returned if the operation is
          successful.

     sssseeeettttVVVVaaaallll(((())))

          iflStatus iflLutSetVal(iflLut *obj, double val, double domainIdx,
                                 int chan)


          This function sets the look-up table entry for channel, _c_h_a_n, and
          input value, _d_o_m_a_i_n_i_d_x.  The value given by _v_a_l is converted to the
          internal data type of the table.  If the entry indicated is not
          contained in the iflLut, a value of iflBADPARAMS is returned;



                                                                        PPPPaaaaggggeeee 5555






iiiiffffllllLLLLuuuutttt((((3333))))         IIIImmmmaaaaggggeeee FFFFoooorrrrmmmmaaaatttt LLLLiiiibbbbrrrraaaarrrryyyy CCCC++++++++ RRRReeeeffffeeeerrrreeeennnncccceeee MMMMaaaannnnuuuuaaaallll          iiiiffffllllLLLLuuuutttt((((3333))))



          iflOKAY is returned if the operation is successful.  The domain
          index is scaled as needed to map onto the actual table entries when
          the table length does not map one to one onto the domain.

SSSSEEEEEEEE AAAALLLLSSSSOOOO
     iflColormap, iflSGIColormap

















































                                                                        PPPPaaaaggggeeee 6666